home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 12 / BBS in a box XII-1.iso / Files / Tele / C / Comet2.1.3.sit / Comet / hyperface.c / hyperface.c
Encoding:
C/C++ Source or Header  |  1990-09-13  |  8.5 KB  |  531 lines  |  [TEXT/MPS ]
  1. /*    Copyright 1986 Cornell University                                        */
  2.  
  3. #include <em.h>
  4.  
  5. #include <3270.h>                   /* external variables & constants     */
  6. #include <cntldefs.h>
  7. #include <tftp.h>
  8. #include <resdefs.h>
  9.  
  10. #include <rcodes.h>
  11. #include <h19.h>
  12.  
  13. #include "::3270XCMD:TNdrvr.h" 
  14.  
  15.  
  16.  
  17. /* Here follows a slew of Hypercard interface routines;
  18.     all of the routines must save and restore A5 since the calls come from 
  19.     another MF application heap through the TNdrvr */
  20.  
  21. /* MPW uses d0/d1/a0/a1 as scratch so we must preserve Aztec scratch regs */
  22.  
  23. #asm
  24.  
  25. mpwcregs    reg    d3/a2
  26.  
  27. #endasm
  28.  
  29. extern unsigned long getmyA5();
  30.  
  31.  
  32. OSErr tnopen()
  33. {
  34.     unsigned long oldA5;
  35.     OSErr retval = 0;
  36.     
  37.     oldA5 = getmyA5();
  38. #asm
  39.     movem.l    mpwcregs,-(a7)
  40. #endasm
  41.  
  42.     if (!keydp->hycactive) {
  43.         keydp->hycactive = TRUE;
  44.     }
  45.     else
  46.         retval = HTNR_ACTIVE;
  47.     
  48.     setA5(oldA5);
  49. #asm
  50.     movem.l    (a7)+,mpwcregs
  51. #endasm
  52.     return(retval);
  53. }
  54.  
  55.  
  56. /* open a connection with a host 
  57.     failure codes:    1 = already connected
  58.                     2 = can't resolve name
  59.                     3 = invalid address
  60.                     4 = can't reach host
  61. */
  62.  
  63. OSErr tnconnect(hoststrp)
  64. char * hoststrp;
  65. {
  66.     unsigned long oldA5;
  67.     OSErr retval = 0;
  68.     OSErr connalready = FALSE;
  69.     OSErr connfail = FALSE;
  70.     
  71.     oldA5 = getmyA5();
  72. #asm
  73.     movem.l    mpwcregs,-(a7)
  74. #endasm
  75.     if (!keydp->hycactive)
  76.         retval = HTNR_ACTIVE;
  77.     else if (!keydp->connopen) {
  78.         if (!resolve_name(hoststrp, &keydp->fhost)) {
  79.             if ((keydp->fhost.u.addr == 0L) || (keydp->fhost.u.addr == -1L) ) {
  80.                 retval = HTNR_ADDR;
  81.             }
  82.             else {
  83.                 /* make hhostname reflect the hostname */
  84.                 if (keydp->hhostname != NULL)
  85.                     DisposHandle(keydp->hhostname);
  86.                 keydp->hhostname = NewHandle((long) strlen(hoststrp));
  87.                 strcpy(*keydp->hhostname, hoststrp);
  88.                 ctop(*keydp->hhostname);
  89.                 
  90.                 keydp->hycconnwait = TRUE;
  91.                 /* makeconn(); 
  92.                     check keydp->hycconnwait in main() loop instead
  93.                     since MacTCP sync business is uncool...
  94.                 */
  95.             }
  96.         }
  97.         else {
  98.             retval = HTNR_NAME;
  99.         }
  100.             
  101.     }
  102.     else
  103.         retval = HTNR_OPEN;
  104.  
  105.     setA5(oldA5);
  106. #asm
  107.     movem.l    (a7)+,mpwcregs
  108. #endasm
  109.     return(retval);
  110. }
  111.  
  112.  
  113. /* close the current connection */
  114.  
  115. OSErr tnclose()
  116. {
  117.     unsigned long oldA5;
  118.     OSErr retval = 0;
  119.     
  120.     oldA5 = getmyA5();
  121. #asm
  122.     movem.l    mpwcregs,-(a7)
  123. #endasm
  124.  
  125.     if (!keydp->hycactive)
  126.         retval = HTNR_ACTIVE;
  127.     else if (!keydp->connopen)
  128.         retval = HTNR_OPEN;
  129.     else {
  130.         tcp_close();
  131.     }
  132.  
  133.     setA5(oldA5);
  134. #asm
  135.     movem.l    (a7)+,mpwcregs
  136. #endasm
  137.     return(retval);
  138. }
  139.  
  140.  
  141. /* the 3270 driver client no longer requires our services */
  142.  
  143. OSErr tnquit()
  144. {
  145.     unsigned long oldA5;
  146.     
  147.     oldA5 = getmyA5();
  148. #asm
  149.     movem.l    mpwcregs,-(a7)
  150. #endasm
  151.     
  152.     keydp->hycactive = FALSE;
  153.     keydp->userquit = TRUE;
  154.     tcp_close();
  155.  
  156.     cu_exit(0);
  157.     
  158.     setA5(oldA5);
  159. #asm
  160.     movem.l    (a7)+,mpwcregs
  161. #endasm
  162.     return(0);
  163. }
  164.  
  165.  
  166. /* put a string into the 3270 buffer; TAB = field Tab, CR = Enter */
  167.  
  168. OSErr tnsendstr(sendstrp)
  169. char * sendstrp;
  170. {
  171.     OSErr retval = 0;
  172.     unsigned long oldA5;
  173.     struct token atoke;
  174.     struct token tabtoke;
  175.     struct token entertoke;
  176.     
  177.     oldA5 = getmyA5();
  178. #asm
  179.     movem.l    mpwcregs,-(a7)
  180. #endasm
  181.     
  182.     atoke.class = RSLT_ASCI;
  183.     tabtoke.class = RSLT_MVCR;
  184.     tabtoke.entry = TAB_FWD;
  185.     entertoke.class = RSLT_PFKY;
  186.     entertoke.entry = ENTER;
  187.  
  188.     if (!keydp->hycactive)
  189.         retval = HTNR_ACTIVE;
  190.     else if (!keydp->connopen)
  191.         retval = HTNR_OPEN;
  192.     else {
  193.         /* interpret the string */
  194.         while (atoke.entry = *sendstrp++) {
  195. #ifdef TRANSLATE
  196. /* Peter Bosanko prefers no translation for the interface */
  197.             if (atoke.entry == CR) {
  198.                 /* do an Enter when we see a CR */
  199.                 (*dotoken)(&entertoke);
  200.             }
  201.             else if (atoke.entry == TAB) {
  202.                 /* do a field TAB */
  203.                 (*dotoken)(&tabtoke);
  204.             }
  205.             else
  206. #endif
  207.                 putaction(RSLT_ASCI, atoke.entry);
  208.         }
  209.     }
  210.     
  211.     setA5(oldA5);
  212. #asm
  213.     movem.l    (a7)+,mpwcregs
  214. #endasm
  215.     return(retval);
  216. }
  217.  
  218.  
  219. /* execute a tn3270 command token encoded in two strings */
  220.  
  221. OSErr tnsendcmd(class, entry)
  222. char * class;
  223. char * entry;
  224. {
  225.     OSErr retval = 0;
  226.     unsigned long oldA5;
  227.     struct token atoke;
  228.     
  229.     oldA5 = getmyA5();
  230. #asm
  231.     movem.l    mpwcregs,-(a7)
  232. #endasm
  233.     
  234.     if (!keydp->hycactive)
  235.         retval = HTNR_ACTIVE;
  236.     else if (!keydp->connopen)
  237.         retval = HTNR_OPEN;
  238.     else {
  239. #ifndef VALIDATE
  240.     /* no validation is performed on the tokens we're handed ... */
  241.         putaction(*class, *entry);
  242. #else
  243.         atoke.class = *class;
  244.         atoke.entry = *entry;
  245.         switch (*class) {
  246.             case ' ': {
  247.                 /* ascii class */
  248.                 atoke.entry = *entry;
  249.                 putaction(atoke.class, atoke.entry);
  250.                 break;
  251.             }
  252.             case 'A': {
  253.                 /* local action class */
  254.                 if (valaction(*entry)) {
  255.                     atoke.entry = *entry;
  256.                     putaction(atoke.class, atoke.entry);
  257.                 }
  258.                 else 
  259.                     retval = HTNR_ENTRY;
  260.                 break;
  261.             }
  262.             case 'P': {
  263.                 /* PF key class */
  264.                 if ((atoke.entry = hycmappfkey(entry)) != 0) {
  265.                     (*dotoken)(&atoke);
  266.                 }
  267.                 else 
  268.                     retval = HTNR_ENTRY;
  269.                 break;
  270.             }
  271.             case 'M': {
  272.                 /* cursor motion class */
  273.                 if (valcursor(*entry)) {
  274.                     atoke.entry = *entry;
  275.                     (*dotoken)(&atoke);
  276.                 }
  277.                 else 
  278.                     retval = HTNR_ENTRY;
  279.                 break;
  280.             }
  281.             case 'X': {
  282.                 /* move to x coord class */
  283.                 atoke.entry = atoi(class);
  284.                 if (atoke.entry >= 80)
  285.                     retval = HTNR_ENTRY;
  286.                 else
  287.                     (*dotoken)(&atoke);
  288.                 break;
  289.             }
  290.             case 'Y': {
  291.                 /* move to y coord  class */
  292.                 atoke.entry = atoi(class);
  293.                 if (atoke.entry >= 24)
  294.                     retval = HTNR_ENTRY;
  295.                 else
  296.                     (*dotoken)(&atoke);
  297.                 break;
  298.             }
  299.             default: {
  300.                 retval = HTNR_CLASS;
  301.                 break;
  302.             }
  303.         }    
  304. #endif
  305.     }
  306.     
  307.     setA5(oldA5);
  308. #asm
  309.     movem.l    (a7)+,mpwcregs
  310. #endasm
  311.     return(retval);
  312. }
  313.  
  314.  
  315. /* return the tn3270 status */
  316.  
  317. OSErr tnstatus(bufptr)
  318. char * bufptr;
  319. {
  320.     unsigned long oldA5;
  321.     long scrp;
  322.     OSErr retval = 0;
  323.     
  324.     oldA5 = getmyA5();
  325. #asm
  326.     movem.l    mpwcregs,-(a7)
  327. #endasm
  328.     
  329.     bufptr = NULL;
  330.     
  331.     if (!keydp->hycactive)
  332.         retval = HTNR_ACTIVE;
  333.     else {
  334.         if (keydp->hycnewdata) {
  335.             retval = HTNS_NEWDATA;
  336.             keydp->hycnewdata = FALSE;
  337.         }
  338.         else if (keydp->hycconnwait) {
  339.             retval = HTNS_WAITCONN;
  340.         }
  341.         else if (nnrup) {
  342.             retval = HTNS_WAITNET;
  343.         }
  344.         else if (keydp->event_reg & KYBD_LOCK) {
  345.             retval = HTNS_KBDLOCK;
  346.         }
  347.         else if (!keydp->connopen) {
  348.             retval = HTNR_OPEN;
  349.         }
  350.         else 
  351.             /* retval = HTNS_RUNNING; */
  352.             retval = screenstate();
  353.     }
  354.  
  355.     setA5(oldA5);
  356. #asm
  357.     movem.l    (a7)+,mpwcregs
  358. #endasm
  359.     return(retval);
  360. }
  361.  
  362.  
  363. /* draw the tn3270 screen into a grafport */
  364.  
  365. OSErr tndraw(qdport)
  366. GrafPtr qdport;
  367. {
  368.     OSErr retval;
  369.     unsigned long oldA5;
  370.     
  371.     oldA5 = getmyA5();
  372. #asm
  373.     movem.l    mpwcregs,-(a7)
  374. #endasm
  375.  
  376.     if (!keydp->hycactive)
  377.         retval = HTNR_ACTIVE;
  378.     else if (!keydp->connopen)
  379.         retval = HTNR_OPEN;
  380.     else {
  381.         ;
  382.     }
  383.     
  384.     setA5(oldA5);
  385. #asm
  386.     movem.l    (a7)+,mpwcregs
  387. #endasm
  388.     return(retval);
  389. }
  390.  
  391.  
  392. hyc_init()
  393. {
  394.     ParamBlkRec drvpb;
  395.     long * arg;
  396.     struct storage tndarr;
  397.     
  398.     drvpb.ioNamePtr = "\P.TNdrvr";
  399.     drvpb.u.iop.ioPermssn = fsCurPerm;
  400.     PBOpen(&drvpb, (Boolean) FALSE);
  401.     if (drvpb.ioResult) {
  402.         return(-1);
  403.     }
  404.     
  405.     drvpb.u.cp.csCode = HTN_INIT;
  406.     
  407.     /* set up arguments in array */
  408.     tndarr.tnopen = tnopen;
  409.     tndarr.tnconnect = tnconnect;
  410.     tndarr.tnstatus = tnstatus;
  411.     tndarr.tnclose = tnclose;
  412.     tndarr.tnquit = tnquit;
  413.     tndarr.tnsendstr = tnsendstr;
  414.     tndarr.tnsendcmd = tnsendcmd;
  415.     tndarr.tndraw = tndraw;
  416.  
  417.     tndarr.tnscreen = scr_map;
  418.     tndarr.tncursor = &cursor_ptr;
  419.     tndarr.tnfield = ¤t_attr;
  420.     
  421.     arg = &drvpb.u.cp.csParam.diskBuff;
  422.         /* point at first parameter */
  423.     *arg = (long *) &tndarr;
  424.     
  425.     PBControl(&drvpb, (Boolean) FALSE);
  426.     if (drvpb.ioResult)
  427.         return(-1);
  428.     
  429. }
  430.  
  431. hycinform()
  432. {
  433.     keydp->hycnewdata = TRUE;
  434. }
  435.  
  436.  
  437. /* check to see if MORE has appeared on the screen to indicate holding */
  438.  
  439. screenstate()
  440. {
  441.     if (!strncmp(&scr_map[1900], "RUNN", 4)) {
  442.         return(HTNS_RUNNING);                        /* == 0 */
  443.     }
  444.     else if (!strncmp(&scr_map[1900], "MORE", 4)) {
  445.         return(HTNS_MORE);
  446.     }
  447.     else if (!strncmp(&scr_map[1900], "VM R", 4)) {
  448.         return(HTNS_VMREAD);
  449.     }
  450.     else if (!strncmp(&scr_map[1900], "CP R", 4)) {
  451.         return(HTNS_CP);
  452.     }
  453.     else if (!strncmp(&scr_map[1900], "HOLD", 4)) {
  454.         return(HTNS_HOLDING);
  455.     }
  456.     else
  457.         return(HTNS_RUNNING);
  458. }
  459.  
  460.  
  461. /* return TRUE if valid action entry */
  462.  
  463. valaction(thechar)
  464. char thechar;
  465. {
  466.     switch (thechar) {
  467.         case 'I':
  468.         case 'D':
  469.         case 'E':
  470.         case 'X':
  471.         case 'B':
  472.         case 'R':
  473.             return(TRUE);
  474.         default:
  475.             return(FALSE);
  476.     }
  477. }
  478.  
  479. valcursor(thechar) 
  480. char thechar;
  481. {
  482.     switch (thechar) {
  483.         case 'L':
  484.         case 'D':
  485.         case 'U':
  486.         case 'R':
  487.         case '0':
  488.         case '>':
  489.         case '<':
  490.         case 'N':
  491.             return(TRUE);
  492.         default:
  493.             return(FALSE);
  494.     }
  495. }
  496.  
  497. hycmappfkey(entry)
  498. char * entry;
  499. {
  500.     int val;
  501.     
  502.     if (*entry >= '0' && *entry <= '9') {
  503.         /* probably numeric */
  504.         val = atoi(entry);
  505.         if (val > 0 && val <= 36) {
  506.             return(val);
  507.         }
  508.     }
  509.     else {
  510.         /* map characters to weird integer values */
  511.         switch (*entry) {
  512.             case 'a': {
  513.                 return(PA1);
  514.             }
  515.             case 'b': {
  516.                 return(PA2);
  517.             }
  518.             case 'c': {
  519.                 return(PA3);
  520.             }
  521.             case 'C': {
  522.                 return(CLEAR);
  523.             }
  524.             case 'E': {
  525.                 return(ENTER);
  526.             }
  527.         }
  528.     }
  529.     return(0);
  530. }
  531.